package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade CLASSE_VAZAO_VOLUME
 * @author Gerado pelo Telescope
 */
public class EntClasseVazaoVolume extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.CLASSE_VAZAO_VOLUME";
    public final static String TABLE_NAME = "CLASSE_VAZAO_VOLUME";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntClasseVazaoVolume() {
        super();
        initialize();
    }
    
    public EntClasseVazaoVolume(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aVolumeLitrosHora = new DomDouble(this,"VOLUME_LITROS_HORA", "Vazão esperada em L/h"); 
        aVolumeLitrosHora.setRequired(true);
        oVolumeLitrosHora = new DomDouble();
        aVolumeEsperadoEscoar = new DomDouble(this,"VOLUME_ESPERADO_ESCOAR", "Massa a escoar em KG"); 
        aVolumeEsperadoEscoar.setRequired(true);
        oVolumeEsperadoEscoar = new DomDouble();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Vazão esperada em L/h
    private DomDouble aVolumeLitrosHora;
    private DomDouble oVolumeLitrosHora;
    
    // Massa a escoar em KG
    private DomDouble aVolumeEsperadoEscoar;
    private DomDouble oVolumeEsperadoEscoar;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntClasseVazaoVolume id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VOLUME_LITROS_HORA">
    
    public EntClasseVazaoVolume volumeLitrosHora(Double value) {
        setVolumeLitrosHora(value);
        return this;
    }
    
    public void setVolumeLitrosHora(DomDouble value) {
        if (value == null || value.isNull()) {
            nullifyVolumeLitrosHora();
        } else {
            aVolumeLitrosHora.setValue(value.getValue());
            if (aVolumeLitrosHora.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVolumeLitrosHora(String value) {
        if (value == null) {
            nullifyVolumeLitrosHora();
        } else {
            aVolumeLitrosHora.setValue(value);
            if (aVolumeLitrosHora.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVolumeLitrosHora(Double value) {
        aVolumeLitrosHora.setValue(value);
        if (aVolumeLitrosHora.isModified()) {
            setModified(true);
        }
    }
    
    public void setVolumeLitrosHora(Object value) {
        aVolumeLitrosHora.setValue(value);
        if (aVolumeLitrosHora.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyVolumeLitrosHora() {
        if (!aVolumeLitrosHora.isNull()) {
            aVolumeLitrosHora.setNull(true);
            setModified(true);
        }
    }
    
    public DomDouble getVolumeLitrosHora() {
        return aVolumeLitrosHora;
    }
    
    public DomDouble oldVolumeLitrosHora() {
        return oVolumeLitrosHora;
    }
    
    public Double valueOfVolumeLitrosHora() {
        return aVolumeLitrosHora.getValue();
    }
    
    public boolean isVolumeLitrosHoraModified() {
        return aVolumeLitrosHora.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VOLUME_ESPERADO_ESCOAR">
    
    public EntClasseVazaoVolume volumeEsperadoEscoar(Double value) {
        setVolumeEsperadoEscoar(value);
        return this;
    }
    
    public void setVolumeEsperadoEscoar(DomDouble value) {
        if (value == null || value.isNull()) {
            nullifyVolumeEsperadoEscoar();
        } else {
            aVolumeEsperadoEscoar.setValue(value.getValue());
            if (aVolumeEsperadoEscoar.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVolumeEsperadoEscoar(String value) {
        if (value == null) {
            nullifyVolumeEsperadoEscoar();
        } else {
            aVolumeEsperadoEscoar.setValue(value);
            if (aVolumeEsperadoEscoar.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVolumeEsperadoEscoar(Double value) {
        aVolumeEsperadoEscoar.setValue(value);
        if (aVolumeEsperadoEscoar.isModified()) {
            setModified(true);
        }
    }
    
    public void setVolumeEsperadoEscoar(Object value) {
        aVolumeEsperadoEscoar.setValue(value);
        if (aVolumeEsperadoEscoar.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyVolumeEsperadoEscoar() {
        if (!aVolumeEsperadoEscoar.isNull()) {
            aVolumeEsperadoEscoar.setNull(true);
            setModified(true);
        }
    }
    
    public DomDouble getVolumeEsperadoEscoar() {
        return aVolumeEsperadoEscoar;
    }
    
    public DomDouble oldVolumeEsperadoEscoar() {
        return oVolumeEsperadoEscoar;
    }
    
    public Double valueOfVolumeEsperadoEscoar() {
        return aVolumeEsperadoEscoar.getValue();
    }
    
    public boolean isVolumeEsperadoEscoarModified() {
        return aVolumeEsperadoEscoar.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            e = new AdsException("ZTEST.CLASSE_VAZAO_VOLUME.GET_ERRORS_UNKNOWN",
                    AdsException.UNKNOWN,
                    "Erro não esperado: " + errorMsg);
        } else {
            if (msg.indexOf("UK_VAVLE_VOLUME_LITRO") >= 0) {
                e = new AdsException("ZTEST.CLASSE_VAZAO_VOLUME.UK_VAVLE_VOLUME_LITRO", 
                        Severity.ERROR,
                        "Registro duplicado! Volume por litro deve ser único. Vazão esperada em L/h ${VOLUME_LITROS_HORA} (UK_VAVLE_VOLUME_LITRO)");
                return e;
            } else if (msg.indexOf("PK_VAVLE") >= 0) {
                e = new AdsException("ZTEST.CLASSE_VAZAO_VOLUME.PK_VAVLE", 
                        Severity.ERROR,
                        "ID duplicado! (PK_VAVLE)");
                return e;
            } else {
                e = new AdsException("ZTEST.CLASSE_VAZAO_VOLUME.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aVolumeLitrosHora);
            allAttributes.add(aVolumeEsperadoEscoar);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getVolumeLitrosHora().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByVolumeLitrosHora(double volumeLitrosHora) throws AdsException {
        findBy(new String[] {"VOLUME_LITROS_HORA"},
                new Object[] {volumeLitrosHora});
    }
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oVolumeEsperadoEscoar.setValue(aVolumeEsperadoEscoar);
        oVolumeLitrosHora.setValue(aVolumeLitrosHora);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntClasseVazaoVolume.class);
            rule.setName("PK_VAVLE");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntClasseVazaoVolume.class);
            rule.setName("UK_VAVLE_VOLUME_LITRO");
            rule.addAttribute(new DomDouble("VOLUME_LITROS_HORA",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
}
